'''
1、多任务：同一时间完成多个任务
2、两种表现形式
  ① 并发：各个任务交替执行，1-2-3-1.....
  ② 并行：在一段时间内，真正的同时一起执行多个任务
3、进程：
     ① 概念：process，是操作系统进行资源分配和调度运行的基本单位（最小单位）-如：正在运行的qq、微信都是进程
             与其他进程不共享资源
     ② 创建进程：
           import multiprocessing
           coding_process = multiprocessing.Process(target = coding)
           music_process  = multiprocessing.Process(target = music)
           coding_process.start()
           music_process.start()
     ③ 获取进程编号：
        当前进程编号   getpid()
        当前父进程编号 getppid()
4、线程：
     ① 概念：是程序执行的最小单位，一个进程最少有一个线程
             与同一进程中的其他线程共享进程所拥有的全部资源
             多个线程之间的执行是无序的
     ② 创建线程：
           import threading
           coding_thread = threading.Thread(target=coding)
           coding_thread.start()
     ③ 线程之间共享全局变量，数据出现错误：
           31、线程同步方法：互斥锁（对共享数据进行锁定，同一时刻只能一个线程操作）
           32、互斥锁的使用：
                 mutex = threading.Lock()
                 mutex.acquire()
                 mutex.release()
           33、死锁：
                 把sum1和sum2的mutex.release()删掉，不释放锁，就会造成死锁，结果只打印出sum1的，sum2的结果无显示
5、进程和线程的区别
     ① 关系对比：
          线程依附在进程中，无进程就无线程
          1进程默认提供1线程，1进程可创建多线程
     ② 区别对比：
          进程之间不共享全局变量
          线程之间共享全局变量
          创建进程的资源开销比线程的大
          进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
          线程不能独立运行，必须依附在进程中
     ③ 优缺点对比：
          优点：进程可用多核    缺点： 进程开销大
               线程开销小           线程不能用多核
import multiprocessing
import time
import os
def coding(num, name):
    for i in range(num):
        # print("coding-----")
        print(f"coding进程：{os.getpid()}")
        print(f"coding父进程：{os.getppid()}")
        print(name)
        time.sleep(0.2)

def music(count):
    for i in range(count):
        # print("music-----")
        print(f"music进程：{os.getpid()}")
        print(f"music父进程：{os.getppid()}")
        time.sleep(0.2)

if __name__ == '__main__':
    print(f"主进程编号：{os.getpid()}")
    # coding()
    # music()
    coding_process = multiprocessing.Process(target=coding, args=(3, "船只"))
    music_process = multiprocessing.Process(target=music, kwargs={"count": 3})
    coding_process.start()
    music_process.start()


# import os
# # 获取包括逻辑核心在内的总核心数
# total_cores = os.cpu_count()
# print(f"总核心数（包括逻辑核心）: {total_cores}")
import multiprocessing
import time

list=[]
def w():
    for i in range(3):
        list.append(i)
    print(list)

def r():
    print(list)

if __name__ == '__main__':
    w_process = multiprocessing.Process(target=w)
    r_process = multiprocessing.Process(target=r)
    w_process.start()
    time.sleep(3)
    r_process.start()

import multiprocessing
import threading
import time
def work():
    for i in range(10):
        print("工作ing....")
        time.sleep(0.2)
if __name__ == '__main__':
    work_process = multiprocessing.Process(target=work)
    work_process.daemon = True  # 守护主进程（在子进程start前设置）

    work_thread = threading.Thread(target=work, daemon=True)  # 守护主线程
    work_thread.daemon = True  # 销毁子线程
    work_process.start()

    time.sleep(1)
    # work_process.terminate()   # 销毁子进程

    print("主进程结束了")

import threading
import time
def get():
    time.sleep(0.5)
    current_thread = threading.current_thread()
    print(f"线程信息是：{current_thread}")

if __name__ == '__main__':
    for i in range(10):
        get_thread = threading.Thread(target=get)
        get_thread.start()
'''

import threading
import time

n = 0
def sum1():
    mutex.acquire()
    for i in range(1000000):
        global n
        n += 1
    mutex.release()
    print(f"sum1:{n}")

def sum2():
    mutex.acquire()
    for i in range(1000000):
        global n
        n += 1
    mutex.release()
    print(f"sum2:{n}")

if __name__ == '__main__':
    mutex = threading.Lock()
    sum1_thread = threading.Thread(target=sum1)
    sum2_thread = threading.Thread(target=sum2)
    sum1_thread.start()
    sum2_thread.start()

























